{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Install and Setup\n",
    "\n",
    "Work with maps and geospatial data in Python using The ArcGIS API for Python.\n",
    "\n",
    "Use simple and efficient tools powered by Web GIS, for sophisticated vector and raster analysis, geocoding, map making, routing and directions. Administer, organize and manage users, groups and information items in your GIS.\n",
    "\n",
    "This library enables access to ready-to-use maps and curated geographic data from Esri and other authoritative sources, and works with your own data as well. It integrates well with the scientific Python ecosystem and includes rich support for Pandas and Jupyter notebook.\n",
    "\n",
    "See below for options to install arcgis and its dependencies:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of Contents\n",
    "* [Installation for ArcGIS Pro 3.0 and later](#Installation-for-ArcGIS-Pro-3.0-and-later)\n",
    "    * [Installation using Python Package Manager](#Installation-using-Python-Package-Manager)\n",
    "    * [Installation using Python Command Prompt](#Installation-using-Python-Command-Prompt)\n",
    "    * [Upgrade package](#Upgrade-package)\n",
    "* [Installation using Anaconda for Python Distribution](#Installation-using-Anaconda-for-Python-Distribution)\n",
    "    * [conda](#Conda)\n",
    "    * [Pipenv](#Pipenv)\n",
    "* [Install with minimum dependencies](#Install-with-minimum-dependencies)\n",
    "* [Installation as a Docker image](#Installation-as-a-Docker-image)\n",
    "* [Install in Google Colaboratory](#Install-in-Google-Colaboratory)\n",
    "* [Install Offline](#Install-Offline)\n",
    "    * [1. While in a connected environment, download the appropriate software you'll need:](#1.-While-in-a-connected-environment,-download-the-appropriate-software-you'll-need:)\n",
    "    * [2. Configure Anaconda for use in the disconnected enviroment:](2.-Configure-Anaconda-for-use-in-the-disconnected-enviroment:)\n",
    "    * [3. Verify the install:](#3.-Verify-the-install:)\n",
    "* [Installation for older versions](#Installation-for-older-versions)\n",
    "* [Install deep learning dependencies](#Install-deep-learning-dependencies)\n",
    "    * [Using the Deep Learning Frameworks Installer](#Using-the-Deep-Learning-Frameworks-Installer)\n",
    "    * [Install using Python Command Prompt or Anaconda](#Install-using-Python-Command-Prompt-or-Anaconda)\n",
    "* [Test your install with jupyter notebook](#Test-your-install-with-jupyter-notebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are multiple ways in which you can experience the ArcGIS API for Python. The ArcGIS API for Python is distributed as a conda package named `arcgis`. [Conda](https://conda.io/projects/conda/en/latest/user-guide/getting-started.html) is a popular Python package and environment manager application that helps you install and update packages such as the ArcGIS API for Python and their dependencies."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation for ArcGIS Pro 3.0 and later"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has a rich collection of packages that can be used in [ArcGIS Pro](https://pro.arcgis.com/en/pro-app/latest/get-started/download-arcgis-pro.htm). To simplify the use of Python packages, ArcGIS Pro includes a package management system called [conda](https://conda.io/en/latest/). Conda takes the guesswork and hassle out of installing and updating packages and their dependencies.\n",
    "\n",
    "To further extend the versatility and utility of Python packages, multiple installations of Python can coexist on a single workstation, independent of one another. Each of these installations is referred to as a Python environment. Each Python environment can have its own set of packages, allowing you to switch between sets of Python functionality without uninstalling and reinstalling packages each time.\n",
    "\n",
    "By default, ArcGIS Pro has a single conda environment, arcgispro-py3, which includes all Python libraries used by ArcGIS Pro as well as several others, such as scipy and pandas.\n",
    "\n",
    "> Note: The most recent ArcGIS Pro 3.1 ships with the ArcGIS API for Python 2.1.0 installed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installation using Python Package Manager"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Starting from version 2.5, ArcGIS Pro releases ship with conda and the `arcgis` package pre-installed. The functionality of conda is integrated into ArcGIS Pro through the `Python Package Manager`. The Python Package Manager removes many of the hurdles faced when writing Python code. It supports installing open-source and third-party libraries that are associated with an individual project, rather than the base Python installation. This simplifies the process of successfully sharing complex Python tools across multiple computers."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ArcGIS Pro 2.5 and later provide the Python Package Manager GUI to download and install any conda package. Access it through the ArcGIS Pro backstage area:\n",
    "  * Open ArcGIS Pro with a new blank Project\n",
    "  * Select the **Project** tab to access the Pro backstage (see screen shot below)\n",
    "  * Select the **Package Manager** menu option\n",
    "  * You will see a list of packages installed in the default **arcgispro-py3** environment. In order to add more packages, you can do the following: \n",
    "  - click on the **Environment Manager** button, then click **Clone arcgispro-py3**\n",
    "    ![python package manager mng envts](../../static/img/ppm_mng_env.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    " * Modify the path and name if you choose, and click `OK`\n",
    " \n",
    "   ![python packagemanager new](../../static/img/ppm_mng_env_new.png)\n",
    "\n",
    "* **Allow environment creation to complete.** Proceeding before this completes could result in an incomplete environment that may not perform properly.\n",
    "   ![python package manager progress bar](../../static/img/ppm_env_create_progress.png)\n",
    "   \n",
    " * Select the new enviroment, right-click and select `Activate`, and click `OK` when complete\n",
    " \n",
    "   ![python_package_manager_active](../../static/img/ppm_active_env.png)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The environment is now the active environment.\n",
    "\n",
    "You can now review the `Installed` packages, as wells as use the `Updates` and `Add Packages` options to modify this cloned environment to meet your needs.\n",
    "\n",
    "   ![python_package_manager_menu](../../static/img/ppm_mng_env_menu.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Installation using Python Command Prompt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ArcGIS Pro provides the Python Command Prompt to download and install any conda package. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   * Navigate to **Start** Menu &gt; **All Programs** &gt; **ArcGIS** &gt; **Python Command Prompt**\n",
    "   \n",
    "> **Note:** By default, the Python Command Prompt opens in the ArcGIS Pro default `arcgispro-py3` environment directory, usually `C:\\Program Files\\ArcGIS\\Pro\\bin\\Python\\envs\\arcgispro-py3\\`, with this default\n",
    "conda environment active. You cannot modify the packages in this environment. In order to add more packages, you need to create a clone of the default **arcgispro-py3** environment. Follow the steps in the [create environment](https://support.esri.com/en/technical-article/000020560) technical article to clone an environment. You can then change the default environment that future ArcGIS Pro and Python Command Prompt sessions use to this cloned environment using the command: ``proswap <new enviroment name>``. See [Access conda from a command prompt](https://pro.arcgis.com/en/pro-app/latest/arcpy/get-started/what-is-conda.htm#ESRI_SECTION1_8A64271AB672480A8785CF3515C3CCFC) for additional information."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "   * Enter the following at the prompt. Entering no release number installs the current release of the ArcGIS API for Python:\n",
    "\n",
    "    ```conda install -c esri arcgis=<release_number>```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"data:image/PNG; base64, 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\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Upgrade package"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Note:** The default _arcgispro-py3_ environment cannot be modified. Clone the default environment in order to create environments where packages can be updated.\n",
    "\n",
    "- The Python Package Manager cannot be used to update the `arcgis` package. Use the **Python Command Prompt** as described below:\n",
    "\n",
    "     * Navigate to **Start** > **ArcGIS** > **Python Command Prompt**\n",
    "     * Activate the environment containing the _arcgis_ package to upgrade. Enter the following at the prompt for an environment named _arcggispro-py3-clone_:\n",
    "          \n",
    "          - `activate arcgispro-py3-clone`\n",
    "      \n",
    "     * Upgrade the _arcgis_ package to the current release by installing from the _esri_ channel with no release number. Enter the following at the prompt:\n",
    "          \n",
    "          - `conda install -c esri arcgis`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Note:** Install a specific release of `arcgis` using a release number: `conda install -c esri arcgis=<release_number>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Installation using Anaconda for Python Distribution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### conda\n",
    "Open a terminal application, navigate to the directory you want to work in, and activate the conda `environment` you want to use with the ArcGIS API for Python. Install the API with the following command:\n",
    "\n",
    "``conda install -c esri arcgis``\n",
    "\n",
    "> Note: You can also use the `-n <environment_name>` flag to install the package into an environment of your choosing.                                                                                                            \n",
    "\n",
    "For more detials, read [here](https://developers.arcgis.com/python/guide/understanding-conda/).\n",
    "\n",
    "### Pipenv\n",
    "[Pipenv](https://docs.pipenv.org/) is the official packaging tool for managing environments and installing packages from the [Python Package Index (PyPI)](https://pypi.python.org/pypi). To install the ArcGIS API for Python from PyPI in a new environment, create a new folder named `your-folder`. Then, open a terminal, and run `cd /path/to/your-folder` to change directories into `your-folder`. Next, enter the following command to simultaneously create a new environment and install the API in it:\n",
    "\n",
    "``pipenv install arcgis``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install with minimum dependencies\n",
    "\n",
    "Both `conda install -c esri arcgis` and `pip install arcgis` will install all of the dependencies outlined in the [system requirements](https://developers.arcgis.com/python/guide/system-requirements/) section. However, the API can function in a 'stripped down' state with only a few dependencies. This allows developers to deploy the API with minimal footprint in space constrained environments. For this to work, you need to manually manage the dependencies in your environment based on the applications you need to solve and if you don't want to use every feature of the API. As of `v2.1.0` of the Python API, the minimum dependencies needed include:\n",
    "\n",
    " - `ujson`\n",
    " - `six`\n",
    " - `requests`\n",
    "    - This library has its own dependencies that must be included\n",
    " - `requests-toolbelt`\n",
    " - `requests-kerberos`\n",
    " - `requests-oauthlib`\n",
    " - `requests-gssapi`\n",
    " - `requests_ntlm2`\n",
    "    - This library has its own dependencies that must be included\n",
    "\n",
    "To install the API with no dependencies, simply add the `--no-deps` flag to any install command:\n",
    "  * `conda install -c esri arcgis --no-deps` \n",
    "  * `pip install arcgis --no-deps`\n",
    "\n",
    "The above set of dependencies should allow you to establish a connection with your web GIS and perform a number of administrative and other tasks which involve processing on your GIS rather than in your Python kernel. Depending on your OS, this set up with minimal dependencies should take up about `50` mb in space. As your needs expand, you can then manually choose which dependencies to add to your Python environment. For instance, you can install `pandas` if you require to work with spatially enabled DataFrames and `jupyter`, if you need the notebook IDE."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Install as a Docker image\n",
    "\n",
    "[Docker](https://www.docker.com) is a popular containerization technology. Docker containers bundle software in a complete file system with everything that is needed to run it. Docker containers run the same regardless of your operating system. To learn more about docker, refer to [the official documentation](https://docs.docker.com/engine/getstarted/).\n",
    "\n",
    "The ArcGIS API for Python is shipped as a [Docker image](https://github.com/Esri/arcgis-python-api/pkgs/container/arcgis-python-api-notebook) which you can download and power up whenever you want to use the API. These images when spun up into containers, run in an isolated environment without making any changes to your local file system.\n",
    "\n",
    "Follow the steps below to get Docker on your computer and run the API:\n",
    "\n",
    " * [Download docker](https://www.docker.com/products/overview) and [install](https://docs.docker.com/engine/installation/) it on your computer.\n",
    " * Once installed, run the following command in terminal to pull Docker image\n",
    " \n",
    "     `docker pull ghcr.io/esri/arcgis-python-api-notebook`\n",
    "\n",
    " * Then spin the image into a container using the following command in terminal. Replace the `<localport>` with an available port number, for instance `8889`. \n",
    " \n",
    "     `docker run -it -p <localport>:8888 ghcr.io/esri/arcgis-python-api-notebook`\n",
    "\n",
    "\n",
    " * When the container starts, it will provide a 127.0.0.1 URL (with a one time token) to open your local Notebook instance. Copy the URL and paste it in your browser's address bar to use the notebooks.\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install in Google Colaboratory\n",
    "\n",
    "[Google Colab](https://colab.research.google.com/) is a Google-hosted Jupyter notebook service that allows a user to access their notebooks from anywhere by storing them in [Google Drive](https://drive.google.com/). It requires no setup beyond creating a Google account, and provides free computing resources, including cloud-based GPUs. To learn more, refer to the [FAQ](https://research.google.com/colaboratory/faq.html) or [tutorial](https://colab.research.google.com/drive/16pBJQePbqkz3QFV54L4NIkOn1kwpuRrj). Colab is a very convenient platform for ArcGIS administration and management, as it allows a user to run scripts from wherever they have access to a Google account.\n",
    "\n",
    "Google Colab runs in a cloud virtual machine that uses [Ubuntu](https://ubuntu.com), meaning that it can process bash commands in addition to Python logic. Any command with a `!` in front of it will be treated as if it were entered on the command line. This means that the ArcGIS API for Python can be installed with `pip`.\n",
    "\n",
    "Follow the steps below to install:\n",
    "\n",
    "* If you have not already done so, register an account with Google and open a new Colab notebook.\n",
    "\n",
    "* Add a cell and run `!pip install arcgis`.\n",
    "    - Note: if your account has already been working on a notebook (even a separate one), it may prompt you to restart your runtime in order for this to work. This well reset your environment variables without altering any of your code, allowing you to re-run these commands and install successfully.\n",
    "\n",
    "* You can confirm the installation by running `!pip list`. The list should include arcgis along with all of the proper dependencies found in a normal arcgis install.\n",
    "\n",
    "* Run `import arcgis` to confirm that it works properly.\n",
    "\n",
    "Currently, Google Colab is not readily compatible with the ArcGIS mapping widget, but may work with some functions that return iFrames, such as the `WebExperience.preview()` method. To enable these widgets (or any 3rd-party widget) in Colab, run `from google.colab import output` followed by `output.enable_custom_widget_manager()`. \n",
    "\n",
    ">Note: At the time of writing this, this installation process works for the default version of Python that comes with Colab, 3.10.12. This means that only ArcGIS 2.2.0 and higher can be installed, as prior versions are not compatible with Python 3.10+. Downgrading the Python version in Colab is possible, but may interfere with other dependencies needed to run ArcGIS."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install Offline\n",
    "\n",
    "##### 1. While in a connected environment, download the appropriate software you'll need:\n",
    " * the latest version of the full [Anaconda for Python 3x](https://www.anaconda.com/distribution/) for your OS\n",
    " * the appropriate version of the API for Python package for your OS from [Esri's channel on anaconda.org](https://anaconda.org/Esri/arcgis/files)\n",
    "   * The file names appear in this pattern: `platform/arcgis-x.x.x-pyZZyyyyyyy-y.tar.bz2`. Find your file by substituting:\n",
    "    * your operating system platform for `platform`\n",
    "    * the API release number for `x.x.x`\n",
    "    * your Python version for `ZZ`. \n",
    "    * The `yyyyyyy_y` refers to a hash number created for each conda package uploaded to the channel\n",
    "   \n",
    "   \n",
    "   For instance, if you are installing the Python API 1.6.2 on Windows 64-bit for Python 3.7, download the `win-64/arcgis-1.6.2-py37h42bb103_633.tar.bz2` package. \n",
    "\n",
    "##### 2. Configure Anaconda for use in the disconnected enviroment:\n",
    "\n",
    " * Install Anaconda from your install location. Once installed, you can use the Anaconda Navigator GUI application or the Anaconda Prompt command line console to operate the software. The procedure below outlines using the Anaconda Prompt and the `conda` utility on Windows:\n",
    " \n",
    "   First, open Anaconda Prompt. All subsequent commands are run inside this prompt:\n",
    "   \n",
    "   `Start > Anaconda3 (64-bit) > Anaconda Prompt`\n",
    " \n",
    "    1. Configure Anaconda for [offline](https://docs.conda.io/projects/conda/en/latest/user-guide/configuration/use-condarc.html#offline-mode-only) use. See [`Conda Configuration`](https://docs.conda.io/projects/conda/en/latest/user-guide/configuration/index.html) for full details:    \n",
    "      \n",
    "      `conda config --set offline True`\n",
    "      \n",
    "    2. Create a new environment, including `python` and `six` packages:      \n",
    "      \n",
    "      `conda create -n <my_env_name> python six`\n",
    "    \n",
    "    3. Activate the environment:\n",
    "    \n",
    "      `conda activate <my_env_name>`\n",
    "        \n",
    "    4. Install the API for Python package, having downloaded the `bz2` file that matches the appropriate platform, Python version and API release you are using:\n",
    "      \n",
    "      `conda install /path_to_package_download_folder/platform/arcgis-x.x.x-pyZZyyyyyyy-y.tar.bz2` \n",
    "        \n",
    "        The `conda` utility will pull all the `arcgis` package dependencies from the installed set of Anaconda libraries instead of searching the internet. \n",
    "        \n",
    "\n",
    "##### 3. Verify the install:\n",
    "\n",
    " * At this point, all modules, classes and functions are available in the API for use in your Python scripts or Jupyter notebooks except the [`Map Widget`](https://developers.arcgis.com/python/api-reference/arcgis.widgets.html#mapview). You can verify your install by making a connection to your GIS and printing properties:\n",
    "    ```python\n",
    "     gis = GIS(\"url_to_your_gis\", \"username\", \"password\")\n",
    "     print(f\"Connected to {gis.properties.portalHostname} as {gis.users.me.username}\")\n",
    "    ```\n",
    " * The `map widget` is only supported within [`Jupyter`](https://jupyter.org/) applications. Follow these additional steps to use the map widget in a disconnected environment:\n",
    " \n",
    "   * install the `jupyterlab` package for visualizing with maps in either Jupyter Notebook or Jupyter Lab: \n",
    "        \n",
    "        `conda install jupyterlab`\n",
    "        \n",
    "   * enable the map widget by running these 2 commands in succession:\n",
    "        \n",
    "        1. `jupyter nbextension enable --py --sys-prefix widgetsnbextension`\n",
    "        \n",
    "        2. `jupyter nbextension enable --py --sys-prefix arcgis`\n",
    "   \n",
    "   * proceed to [Test your install with the Jupyter Notebook](#Test-your-install-with-jupyter-notebook) to verify the proper installation of the `map widget`.\n",
    "      \n",
    "      **NOTE**: You may need to configure the map widget to use the Javascript API shipped with the portal you're connecting to in the disconnected environment. If `gis.map()` does not return a map, run the following code to configure the map widget with the Javascript API shipped with the portal:\n",
    "      ```python\n",
    "      MapView.set_js_cdn(\"https://your-portal-host/jsapi4/\")\n",
    "      ```\n",
    "\n",
    "> _NOTE:_ The Web GIS must have a [`Geocoder`](https://developers.arcgis.com/python/api-reference/arcgis.geocoding.html#geocoder) configured as a Utility Service to display a map. See [`here`](https://enterprise.arcgis.com/en/portal/latest/administer/windows/configure-portal-to-geocode-addresses.htm) for details if your portal does not have one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install for older versions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can click [here](https://developers.arcgis.com/python/guide/install-older-versions/) to install `arcgis` for older versions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install deep learning dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you already have an environment with the `arcgis` package installed, you can further install its deep learning dependencies to take advantage of the `arcgis.learn` module. Some of the deep learning samples available [here](https://developers.arcgis.com/python/sample-notebooks/) can be referenced to understand the workflow.\n",
    "\n",
    "**Note:** To use the deep learning capabilities in ArcGIS Pro 2.9 / ArcGIS API for Python 1.9.0 onwards, the minimum required version of the Nvidia GPU driver is 456.38.\n",
    "\n",
    "### Using the Deep Learning Frameworks Installer\n",
    "\n",
    "To work with the deep learning tools in ArcGIS Pro 2.6 and later, you need to install supported deep learning frameworks packages.\n",
    "\n",
    "`Deep Learning Libraries Installer for ArcGIS` is now available at https://github.com/Esri/deep-learning-frameworks. This installer includes a broad collection of components, such as PyTorch, TensorFlow, Fast.ai and scikit-learn, for performing deep learning and machine learning tasks. Note that this will install the deep learning frameworks into your currently active Pro Python environment; if you wish to install in an environment aside from the default arcgispro-py3 environment, switch to that environment before running the MSI using either ArcGIS Pro's Python manager UI or on the command line with proswap. Any subsequent clones of that environment will also include this full collection of packages. \n",
    "\n",
    "For instructions on how to install deep learning frameworks manually or over ArcGIS Image Server, click [here](https://github.com/Esri/deep-learning-frameworks/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Install using Python Command Prompt or Anaconda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For ArcGIS Pro users:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href=\"https://github.com/esri/deep-learning-frameworks\" target=\"_blank\">Deep learning frameworks</a>\n",
    "can be used to install all the required dependencies in  ArcGIS Pro's default python environment using an MSI installer. \n",
    "\n",
    "Alternatively,  \n",
    "for a cloned environment of ArcGIS Pro's default environment, `deep-learning-essentials` metapackage can be used to install the required dependencies which can be done using the following command, in the _`Python Command Prompt`_ <i>(included with ArcGIS Pro)</i>:\n",
    "\n",
    "`conda install deep-learning-essentials`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  For Anaconda users (Windows & Linux platforms):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`arcgis_learn` metapackage can be used for both windows and linux installations of Anaconda in a new environment.\n",
    "\n",
    "The following command will update Anaconda to the latest version.\n",
    "\n",
    "```conda update conda```\n",
    "\n",
    "After that, metapackage can be installed using the command below:\n",
    "\n",
    "```conda install -c esri arcgis_learn=2.1.0 python=3.9```\n",
    "\n",
    "Note: Python version 3.7 and 3.8 are also supported with this command."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test your install with jupyter notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To verify your arcgis installation, run the following commands in jupyter notebook:\n",
    "\n",
    "> **NOTE:** See [Jupyter Browser Compatibility](https://jupyter-notebook.readthedocs.io/en/stable/notebook.html#browser-compatibility) for information on browser support for running the Jupyter Notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<img src=\"\"/>"
      ],
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from arcgis.gis import GIS\n",
    "my_gis = GIS()\n",
    "m = my_gis.map()\n",
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To verify deep learning environment, run the following commands:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``import fastai``\n",
    "\n",
    "``import torch``\n",
    "\n",
    "``import arcgis``"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run this command to check if cuda device is picked up for training a model on GPU.\n",
    "\n",
    "``torch.cuda.is_available()``\n",
    "\n",
    "`` torch.zeros((3, 224, 224)).cuda()``\n",
    "\n",
    ">Note: If you face an error pointing to some issue with driver, you need to update driver. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[This overview](https://developers.arcgis.com/python/guide/overview-of-the-arcgis-api-for-python/) describes how to use ArcGIS API for Python to write Python code, incorporating capabilities such as mapping, query, analysis, geocoding, routing, portal administration, and more. Browse the sample notebooks to get started. You may choose to experience these [sample notebooks](https://developers.arcgis.com/python/sample-notebooks/) in a live environment as they are available as ArcGIS Notebooks."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "> These are temporary environments which are erased after you close the browser tab. If you would like to save your changes, download your notebooks from the `File` menu of the Jupyter notebook IDE."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": false,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": false,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
